// ASTM更新功能实现
// 该文件实现了ASTM标准更新的爬取功能

// 浏览器环境代码 - 只在浏览器环境中执行
if (typeof window !== 'undefined') {
    const { createApp, ref } = Vue;
    const { ElMessage } = ElementPlus;
    
    // 控制台监听器变量
    let astmConsoleLogListener = null;

    // ElMessage挂载全局
    // const app = createApp({});
    // app.use(ElementPlus);
    // app.mount('#app');

    // 获取ASTM进度条元素
    const astmProgressContainer = document.getElementById('astm-progress-container');
    const astmProgressBar = document.getElementById('astm-progress-bar');
    const astmProgressText = document.getElementById('astm-progress-text');

    // 更新ASTM进度条函数
    function updateAstmProgress(percent, show = true) {
        if (show) {
            astmProgressContainer.style.display = 'block';
        } else {
            astmProgressContainer.style.display = 'none';
            return;
        }
        
        astmProgressBar.style.width = `${percent}%`;
        astmProgressText.textContent = `${percent}%`;
    }

    // 定义响应式变量
    // isAstmHeadless: 控制浏览器显示/隐藏模式的开关状态
    // false: 表示浏览器应该隐藏（默认值，与UI开关未选中状态对应）
    // true: 表示浏览器应该显示（与UI开关选中状态对应）
    // 注意：在astm-core.js中，此值会被反转，因为playwright的headless参数与UI提示的含义相反
    const isAstmHeadless = ref(false);

    // 从 DOM 获取元素
    const astmHeadlessSwitchElement = document.getElementById('astm-headless-switch');
    const astmFetchBtn = document.getElementById('astmFetchBtn');
    const astmStopBtn = document.getElementById('astmStopBtn');
    const astmExportBtn = document.getElementById('astmExportBtn');
    const astmLogEl = document.getElementById('astm-log');

    // 处理ASTM浏览器显示/隐藏模式切换
    // 根据isAstmHeadless.value的值更新UI提示
    // isAstmHeadless.value=true（开关选中）：表示浏览器应该显示
    // isAstmHeadless.value=false（开关未选中）：表示浏览器应该隐藏
    function handleAstmStepsSwitch() {
        console.log(`ASTM浏览器已设置为 ${isAstmHeadless.value ? '显示' : '隐藏'}`);
        // 使用ElMessage向用户提示操作步骤切换状态
        ElMessage.info(`ASTM浏览器已设置为${isAstmHeadless.value ? '显示' : '隐藏'}，${isAstmHeadless.value ? '将显示浏览器界面' : '将隐藏浏览器界面'}`);
    }

    // 绑定事件
    if (astmHeadlessSwitchElement) {
        astmHeadlessSwitchElement.addEventListener('change', function() {
            isAstmHeadless.value = astmHeadlessSwitchElement.checked;
            handleAstmStepsSwitch();
        });
    }

    // 添加ASTM日志函数
    function addAstmLog(message, type = 'info') {
        if (!astmLogEl) return;
        
        const timestamp = new Date().toLocaleTimeString();
        let logClass = '';
        
        // 根据日志类型添加不同的样式
        switch(type.toLowerCase()) {
            case 'error':
                logClass = 'log-error';
                break;
            case 'warning':
                logClass = 'log-warning';
                break;
            case 'success':
                logClass = 'log-success';
                break;
            default:
                logClass = 'log-info';
        }
        
        // 添加带样式的日志条目
        astmLogEl.innerHTML += `<div class="${logClass}">[${timestamp}] ${message}</div>`;
        astmLogEl.scrollTop = astmLogEl.scrollHeight;
        
        // 同时发送到控制台监控系统
        if (typeof consoleAPI !== 'undefined') {
            consoleAPI.addConsoleLog(type, `ASTM UI: ${message}`);
        }
    }
    
    // 初始化控制台监控
    function initializeAstmConsoleMonitoring() {
        console.log('ASTM UI: 初始化控制台监控...');
        
        // 检查是否存在控制台API
        if (typeof consoleAPI !== 'undefined') {
            console.log('ASTM UI: 找到控制台API，开始监控');
            
            // 设置控制台日志监听器
            astmConsoleLogListener = (log) => {
                displayAstmConsoleLog(log);
            };
            
            // 开始监听控制台日志
            consoleAPI.onConsoleLog(astmConsoleLogListener);
            
            // 开始控制台监控
            consoleAPI.startConsoleMonitoring();
            
            console.log('ASTM UI: 控制台监控已启动');
        } else {
            console.warn('ASTM UI: 控制台API不可用，使用本地日志');
        }
    }
    
    // 显示控制台日志
    function displayAstmConsoleLog(log) {
        if (!astmLogEl) return;
        
        // 过滤只显示相关的日志（包含ASTM相关关键词）
        const message = log.message || '';
        const isRelevant = message.includes('ASTM') || 
                          message.includes('astm') || 
                          message.includes('正在导入') ||
                          message.includes('浏览器') ||
                          message.includes('页面') ||
                          message.includes('抓取') ||
                          message.includes('标准') ||
                          message.includes('处理') ||
                          message.includes('获取');
        
        if (isRelevant) {
            const timestamp = new Date(log.timestamp).toLocaleTimeString();
            const logEntry = document.createElement('div');
            logEntry.className = `log-entry log-${log.level || 'info'}`;
            logEntry.innerHTML = `<span class="timestamp">[${timestamp}]</span> ${message}`;
            
            astmLogEl.appendChild(logEntry);
            astmLogEl.scrollTop = astmLogEl.scrollHeight;
        }
    }
    
    // 清理控制台监听器
    function cleanupAstmConsoleMonitoring() {
        if (astmConsoleLogListener && typeof consoleAPI !== 'undefined') {
            consoleAPI.removeConsoleLogListeners();
            astmConsoleLogListener = null;
            console.log('ASTM UI: 控制台监听器已清理');
        }
    }

    // 开始获取ASTM更新函数
    async function startAstmFetch() {
        console.log('开始执行startAstmFetch函数');
        
        // 详细检查必要的DOM元素
        if (!astmFetchBtn) {
            console.error('astmFetchBtn元素不存在');
            addAstmLog('错误: 获取按钮元素不存在', 'error');
            return;
        }
        
        if (!astmStopBtn) {
            console.error('astmStopBtn元素不存在');
            addAstmLog('错误: 停止按钮元素不存在', 'error');
            return;
        }
        
        console.log('所有必要DOM元素已确认存在');
        
        astmFetchBtn.disabled = true;
        astmStopBtn.disabled = false;
        
        // 初始化控制台监听
        initializeAstmConsoleMonitoring();
        
        // 清空之前的日志
        if (astmLogEl) {
            astmLogEl.innerHTML = '';
        }
        
        addAstmLog('开始执行ASTM标准更新任务', 'info');
        updateAstmProgress(10);
        
        // 存储Processing提示的引用，以便后续关闭
        let processingMessage = null;
        
        try {
            // 创建Processing提示
            processingMessage = ElMessage.info({
                message: '正在获取ASTM更新，请稍候...',
                duration: 0,  // 设置为0表示不会自动关闭
                showClose: true  // 显示关闭按钮
            });
            
            // 更新进度条
            updateAstmProgress(30);
            
            addAstmLog('调用ASTM核心脚本处理数据...', 'info');
            console.log('调用ASTM核心脚本，参数:', { isHeadless: isAstmHeadless.value });
            
            // 将isAstmHeadless.value作为参数传递给astm-core.js
            // 在astm-core.js中，此参数将被用于控制浏览器的headless模式
            // isAstmHeadless.value=false（开关未选中）：表示浏览器应该隐藏
            // isAstmHeadless.value=true（开关选中）：表示浏览器应该显示
            const scriptParams = {
                pluginName: 'info-update',
                script: './astm/astm-core.js',
                args: [isAstmHeadless.value],
                useRunWithSignal: true  // 使用支持中断的函数
            };
            
            console.log('ASTM核心脚本调用参数:', scriptParams);
            
            const result = await pluginAPI.runPluginScript(scriptParams);
            
            console.log('ASTM核心脚本返回结果:', result);
            console.log('返回结果类型:', typeof result);
            console.log('返回结果是否包含data字段:', result.hasOwnProperty('data'));
            
            if (result.data) {
                console.log('data字段类型:', typeof result.data);
                console.log('data是否为数组:', Array.isArray(result.data));
                if (Array.isArray(result.data)) {
                    console.log('data数组长度:', result.data.length);
                    console.log('data数组第一项:', result.data[0]);
                }
            }
            
            addAstmLog('ASTM核心脚本执行完成', result.success ? 'success' : 'error');
            
            // 脚本执行完成后设置进度为80%
            updateAstmProgress(80);
            
            if (result.success) {
                // 完成进度条
                updateAstmProgress(100);
                
                // 关闭Processing提示
                if (processingMessage) {
                    processingMessage.close();
                }
                
                ElMessage.success({
                    message: 'ASTM标准更新获取成功！',
                    duration: 3000
                });
                
                // 启用导出按钮
                if (astmExportBtn) {
                    astmExportBtn.disabled = false;
                }
            } else {
                // 更新进度条为错误状态
                updateAstmProgress(0, false);
                
                // 关闭Processing提示
                if (processingMessage) {
                    processingMessage.close();
                }
                
                ElMessage.error({
                    message: `ASTM标准更新获取失败: ${result.error || '未知错误'}`,
                    duration: 5000
                });
                
                addAstmLog(`ASTM标准更新获取失败: ${result.error || '未知错误'}`, 'error');
            }
        } catch (error) {
            console.error('ASTM标准更新获取过程中发生错误:', error);
            
            // 更新进度条为错误状态
            updateAstmProgress(0, false);
            
            // 关闭Processing提示
            if (processingMessage) {
                processingMessage.close();
            }
            
            ElMessage.error({
                message: `ASTM标准更新获取过程中发生错误: ${error.message || '未知错误'}`,
                duration: 5000
            });
            
            addAstmLog(`ASTM标准更新获取过程中发生错误: ${error.message || '未知错误'}`, 'error');
        } finally {
            // 重置按钮状态
            astmFetchBtn.disabled = false;
            astmStopBtn.disabled = true;
        }
    }

    // 停止获取ASTM更新函数
    async function stopAstmFetch() {
        console.log('停止ASTM标准更新获取');
        addAstmLog('用户请求停止ASTM标准更新获取', 'warning');
        
        try {
            // 获取当前任务ID
            const taskId = pluginAPI.getCurrentTaskId();
            console.log(`当前ASTM任务ID: ${taskId || '无'}`);
            
            if (!taskId) {
                console.warn('没有正在运行的ASTM更新任务');
                addAstmLog('没有正在运行的ASTM更新任务', 'warning');
                ElMessage.warning({
                    message: '没有正在运行的ASTM更新任务',
                    duration: 3000
                });
                // 不提前返回，让代码继续执行到 finally 块
            } else {
            
            console.log(`正在停止ASTM任务: ${taskId}`);
            addAstmLog(`正在停止任务: ${taskId}`, 'info');
            
            // 调用插件API停止脚本执行
            const result = await pluginAPI.stopPluginScript();
            console.log('停止脚本结果:', result);
            
            if (result.success) {
                addAstmLog('ASTM标准更新获取已停止', 'success');
                ElMessage.success({
                    message: 'ASTM标准更新获取已停止',
                    duration: 3000
                });
            } else {
                addAstmLog(`停止ASTM标准更新获取失败: ${result.error || '未知错误'}`, 'error');
                ElMessage.error({
                    message: `停止ASTM标准更新获取失败: ${result.error || '未知错误'}`,
                    duration: 5000
                });
            }
            }
        } catch (error) {
            console.error('停止ASTM标准更新获取时发生错误:', error);
            addAstmLog(`停止ASTM标准更新获取时发生错误: ${error.message || '未知错误'}`, 'error');
            ElMessage.error({
                message: `停止ASTM标准更新获取时发生错误: ${error.message || '未知错误'}`,
                duration: 5000
            });
        } finally {
            // 清理控制台监听
            cleanupAstmConsoleMonitoring();
            
            // 重置按钮状态
            astmFetchBtn.disabled = false;
            astmStopBtn.disabled = true;
            
            // 隐藏进度条
            updateAstmProgress(0, false);
        }
    }

    // 导出ASTM更新数据函数
    function exportAstmData() {
        addAstmLog('正在导出ASTM更新数据...', 'info');
        
        try {
            // 获取结果数据
            const tableRows = document.querySelectorAll('#astm-results table tbody tr');
            
            if (!tableRows || tableRows.length === 0) {
                ElMessage.warning({
                    message: '没有可导出的数据',
                    duration: 3000
                });
                addAstmLog('没有可导出的数据', 'warning');
                return;
            }
            
            // 构建导出数据
            const exportData = [];
            
            tableRows.forEach(row => {
                const cells = row.querySelectorAll('td');
                if (cells.length >= 5) {
                    exportData.push({
                        standard: cells[0].textContent,
                        version: cells[1].textContent,
                        dateOfPublication: cells[2].textContent,
                        brief: cells[3].textContent,
                        url: cells[4].textContent === '链接' ? '' : cells[4].textContent
                    });
                }
            });
            
            // 创建JSON字符串
            const jsonString = JSON.stringify(exportData, null, 2);
            
            // 创建Blob对象
            const blob = new Blob([jsonString], { type: 'application/json' });
            
            // 创建下载链接
            const url = URL.createObjectURL(blob);
            const a = document.createElement('a');
            a.href = url;
            a.download = `astm_updates_${new Date().toISOString().slice(0, 10)}.json`;
            document.body.appendChild(a);
            a.click();
            document.body.removeChild(a);
            URL.revokeObjectURL(url);
            
            ElMessage.success({
                message: 'ASTM更新数据导出成功',
                duration: 3000
            });
            addAstmLog('ASTM更新数据导出成功', 'success');
        } catch (error) {
            console.error('导出ASTM更新数据时发生错误:', error);
            ElMessage.error({
                message: `导出ASTM更新数据时发生错误: ${error.message || '未知错误'}`,
                duration: 5000
            });
            addAstmLog(`导出ASTM更新数据时发生错误: ${error.message || '未知错误'}`, 'error');
        }
    }

    // 页面加载完成后绑定ASTM相关按钮事件
    window.addEventListener('load', function() {
        // 绑定ASTM更新标签页按钮事件
        if (astmFetchBtn) {
            astmFetchBtn.addEventListener('click', startAstmFetch);
        }

        if (astmStopBtn) {
            astmStopBtn.addEventListener('click', stopAstmFetch);
        }

        if (astmExportBtn) {
            astmExportBtn.addEventListener('click', exportAstmData);
        }
        
        // 绑定清空日志按钮事件
        const clearAstmLogBtn = document.getElementById('clear-astm-log-btn');
        if (clearAstmLogBtn) {
            clearAstmLogBtn.addEventListener('click', function() {
                if (astmLogEl) {
                    astmLogEl.innerHTML = '等待操作...';
                    console.log('已清空ASTM日志');
                }
            });
        }
        
        // 初始化日志
        if (astmLogEl) {
            addAstmLog('ASTM标准更新功能已加载，请点击"获取ASTM更新"按钮开始', 'info');
        }
    });
}